package leetcode;


import org.junit.Test;

import java.util.Arrays;

/**
 * 1128. 等价多米诺骨牌对的数量
 */
public class Solution {


    @Test
    public void test() {

        int[][] dominoes = new int[4][4];

        int[] a = new int[2];
        a[0] = 1;
        a[1] = 2;
        dominoes[0] = a;

        int[] b = new int[2];
        b[0] = 2;
        b[1] = 1;
        dominoes[1] = b;

        int[] c = new int[2];
        c[0] = 3;
        c[1] = 4;
        dominoes[2] = c;

        int[] d = new int[2];
        d[0] = 5;
        d[1] = 6;
        dominoes[3] = d;

//        System.out.println("dominoes = " + Arrays.deepToString(dominoes));

        numEquivDominoPairs(dominoes);

    }


    /**
     * 给你一个由一些多米诺骨牌组成的列表dominoes。
     * 
     * 如果其中某一张多米诺骨牌可以通过旋转 0度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。
     * 
     * 形式上，dominoes[i] = [a, b]和dominoes[j] = [c, d]等价的前提是a==c且b==d，或是a==d 且b==c。
     * 在0 <= i < j < dominoes.length的前提下，找出满足dominoes[i] 和dominoes[j]等价的骨牌对 (i, j) 的数量。
     * 示例：
     * 
     * 输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
     * 输出：1
     * 
     * 提示：
     * 
     * 1 <= dominoes.length <= 40000
     * 1 <= dominoes[i][j] <= 9
     * 
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/number-of-equivalent-domino-pairs
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     *
     * @param dominoes
     * @return
     */
    public int numEquivDominoPairs(int[][] dominoes) {
        int count = 0;

        for (int i = 0; i < dominoes.length; i++) {

            if (
                    i + 1 >= dominoes.length
            ) {
                // 最后一个值就不进行比较了
                break;
            }


            int[] dominoeI = dominoes[i];

            for (int j = i + 1; j < dominoes.length; j++) {
                int[] dominoeJ = dominoes[j];
                if (
                        (dominoeI[0] == dominoeJ[0] && dominoeI[1] == dominoeJ[1]) ||
                                (dominoeI[0] == dominoeJ[1] && dominoeI[1] == dominoeJ[0])
                ) {
                    count++;
                }
            }


        }

        System.out.println("count = " + count);

        return count;
    }

    @Test
    public void testCopy() {
        int[][] dominoes = new int[4][4];

        int[] a = new int[2];
        a[0] = 1;
        a[1] = 2;
        dominoes[0] = a;

        int[] b = new int[2];
        b[0] = 7;
        b[1] = 8;
        dominoes[1] = b;

        int[] c = new int[2];
        c[0] = 3;
        c[1] = 4;
        dominoes[2] = c;

        int[] d = new int[2];
        d[0] = 5;
        d[1] = 6;
        dominoes[3] = d;


        int i = copyCode(dominoes);
        System.out.println("i = " + i);
    }


    int copyCode(int[][] dominoes) {
        int ans = 0;
        //1 <= dominoes[i][j] <= 9，所以最大是99     [0,0],[0,1],[0,2],[0,3],[0,4] 5 6 7 8 9     int [][] 最多有一百种情况
        int[] cp = new int[100];
        for (int[] arr : dominoes) {
            System.out.println("arr = " + Arrays.toString(arr));
            //排序，归为一种    ps：由小到大
            Arrays.sort(arr);
            System.out.println("arr = " + Arrays.toString(arr));

            //因为后加入的牌可以跟前面所有的牌组队，所以组队的数量就是之前所存在的牌的数量   += 运算在前  ++ 运算在后

            // arr[0]*10+arr[1]  可以避免 2+3 = 1+4 的情况吗
            ans += cp[arr[0] * 10 + arr[1]]++;
        }

        return ans;
    }

    @Test
    public void testC() {
        int[] cp = new int[100];
        int a =cp[12]++;
        System.out.println("a = " + a);
        System.out.println("cp = " + Arrays.toString(cp));
    }


}
